package com.twq.corejava;

import java.util.Arrays;

public class TestArray {
    public static void main(String[] args) {

        boolean[] a = new boolean[]{true, false}; // 静态初始化
        System.out.println(Arrays.toString(a));

        int[] src = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        // 插入操作
        int[] dest = insertElement(src, 3, 56);
        System.out.println(Arrays.toString(dest));

        // 删除操作
        dest = removeElement(src, 3);
        System.out.println(Arrays.toString(dest));

        // 总结：
        // 数组插入和删除的时候
        // 1. 申请新数组，占内存
        // 2. 消耗 CPU 资源
        // 数组的缺点：随机插入和随机删除是不高效的
        // 数组的优点：随机访问(通过下标随机查询元素)高效
        // 数组用于随机访问的场景，对于随机插入和随机删除的场景不适合使用数组
        // 数组的特点：长度固定(在一定的场景下称为缺点) -> 列表
    }

    /**
     *  往数组中插入一个元素
     * @param src
     * @param index
     * @param element
     * @return
     */
    private static int[] insertElement(int[] src, int index, int element) {
        // 1. 申请一个新数组
        int[] dest = new int[src.length + 1];

        // 2. 第一次拷贝
        System.arraycopy(src, 0, dest, 0, index);

        // 3. 赋值为新元素
        dest[index] = element;

        // 4. 第二次拷贝
        System.arraycopy(src, index, dest, index + 1, src.length - index);

        return dest;
    }

    /**
     *  从一个数组中删除指定下标的元素
     * @param src
     * @param index
     * @return
     */
    private static int[] removeElement(int[] src, int index) {
        // 1. 申请新的数组
        int[] dest = new int[src.length - 1];

        // 2. 第一次拷贝
        System.arraycopy(src, 0, dest, 0, index);

        // 3. 第二次拷贝
        System.arraycopy(src, index + 1, dest, index, src.length - (index + 1));

        return dest;
    }
}
